package liumeiya.rbac.view;

import liumeiya.rbac.domain.dto.UserDto;
import liumeiya.rbac.domain.vo.DeptVo;
import liumeiya.rbac.domain.vo.Result;
import liumeiya.rbac.domain.vo.RoleVo;
import liumeiya.rbac.domain.vo.UserVo;
import liumeiya.rbac.service.UserService;

import static liumeiya.rbac.view.MainView.printMenu;

public class UserView {

    /**
     * 视图对象缓存数组，⽤于存放从业务层获取的⽤户数据列表
     */
    public static UserVo[] cache;

    /**
     * 输出用户管理菜单
     */
    public static void printMenu(){
        String menu = """
                ------------------
                     用户管理
               ------------------
               |   0...返回上级   |
               |   1...用户列表   |
               |   2...新建用户   |
               |   3...更新用户   |
               |   4...切换状态   |
               -------------------
               请输入选项：""";
        System.out.print(menu);
    }
    
    public static void show() {
        String menuChoice;
        do {
            printMenu();
            menuChoice = MainView.input.nextLine();
            switch (menuChoice) {
                case "0" -> printError("已返回上一级菜单");
                case "1" -> list();
                case "2" -> create();
                case "3" -> update();
                case "4" -> toggle();
                default -> printError("输入非法，请输入正确的菜单编号！");
            }
        } while (!"0".equals(menuChoice));
    }

    /**
     * 使用 System.out 输出红色错误信息。
     *
     * 该方法使用 ANSI 转义码来在控制台输出红色的错误信息。
     *
     * @param message 错误信息
     */
    public static void printError(String message) {
        // ANSI 转义码，\033[31m 表示红色， \033[0m 表示重置为默认颜色
        System.out.println("\033[31m" + message + "\033[0m");
    }


    /**
     * 列出所有⽤户的信息。
     * <p>
     * 本⽅法调⽤服务层获取所有⽤户数据，并将其存储在缓存中。
     * 然后，输出所有⽤户的 ID、⽤户名、姓名、⼿机号、邮箱、部⻔名称和⻆⾊名称
     * 以表格形式显示在控制台中，供⽤户查看。
     * </p>
     */
    public static void list() {
        // 调⽤服务层获取所有⽤户数据
        Result result = UserService.list();

        // 将获取到的⽤户数据存⼊缓存
        cache = (UserVo[]) result.data;

        // 输出表头
        System.out.println("ID\t⽤户名\t姓名\t⼿机号\t邮箱\t部⻔名称\t⻆⾊名称\t状态");

        // 遍历缓存中的每个⽤户对象，输出⽤户信息
        for (UserVo user : cache) {
            // 格式化输出每个⽤户的详细信息
            System.out.printf("%d\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n", user.id, user.username, user.name, user.mobile,
                    user.email, user.deptName, user.roleName,
                    user.enabled ? "启⽤" : "禁⽤");
        }
    }

    /**
     * 创建用户的方法。
     *
     * 此方法引导用户输入必要的用户信息， 并选择所属部门和用户，最后调用 UserService 进行用户创建。
     *
     * 流程如下：
     * 1. 输入用户名、姓名、手机号、邮箱。
     * 2. 选择部门 （需先存在部门，否则提示错误）。
     * 3. 选择用户 （需先存在用户，否则提示错误）。
     * 4. 调用 UserService.create() 创建用户。
     * 5. 根据创建结果反馈成功或错误信息。
     */
    public static void create() {
        // 提示用户输入基本信息
        System.out.print("请输入用户名：");
        String username = MainView.input.nextLine();

        System.out.print("请输入姓名：");
        // 从控制台读取用户输入的姓名
        String name = MainView.input.nextLine();

        System.out.print("请输入手机号：");
        // 从控制台读取用户输入的手机号
        String mobile = MainView.input.nextLine();

        System.out.print("请输入邮箱：");
        // 从控制台读取用户输入的邮箱
        String email = MainView.input.nextLine();

        // 选择部门
        System.out.println("请选择部门 ID");
        int deptId = 0;
        do {
            // 显示所有可选的部门
            DeptView.list();
            if (DeptView.cache == null || DeptView.cache.length == 0) {
                // 如果没有部门数据， 提示错误并返回
                printError("系统还没有任何部门信息，请先创建部门信息。");
                return;
            }
            // 通过用户输入获取选中的部门
            DeptVo dept = DeptView.getCacheById();
            if (dept != null) {
                deptId = dept.id;
            }
        }while (deptId == 0);  // 确保用户必须选择有效的部门 ID

        // 选择用户
        System.out.println("请选择用户 ID：");
        int roleId = 0;
        do {
            // 显示所有可选的用户
            RoleView.list();
            if (RoleView.cache == null || RoleView.cache.length == 0) {
                // 如果没有用户数据， 提示错误并返回
                printError("系统还没有任何用户信息，请先创建用户信息。");
                return;
            }
            // 通过用户输入获取选中的部门
            RoleVo role = RoleView.getCacheById();
            if (role != null) {
                roleId = role.id;
            }
        }while (roleId == 0);  // 确保用户必须选择有效的用户 ID

        // 创建用户数据传输对象 (DTO)
        UserDto dto = new UserDto(username,name,mobile,email,deptId,roleId);

        // 调用服务层创建用户
        Result result = UserService.create(dto);

        // 根据结果判断是否成功创建用户
        if (!result.success) {
            printError(result.message); // 输出错误信息
            return;
        }

        // 创建成功，显示成功信息
        System.out.println(result.message);

        // 刷新用户列表
        list();
    }


    /**
     * 根据⽤户输⼊的 ID 从缓存中查找并返回对应的⽤户信息。
     * <p>
     * 此⽅法会提示⽤户输⼊⼀个 ID，并根据该 ID 查找缓存中的⽤户数据。如果缓存为空，则会
     从服务层获取⽤户列表并缓存。
     * 如果找到了对应 ID 的⽤户，⽅法会打印该⽤户的详细信息，并返回该⽤户的数据。如果未找
     到该 ID 对应的⽤户，
     * 则会输出错误信息并返回 null。
     * </p>
     *
     * @return 如果找到⽤户，返回对应的 {@link UserVo} 对象；如果未找到或输⼊⽆效，返
    回 {@code null}。
     */
    public static UserVo getCacheById() {
        // 提示⽤户输⼊ ID，要求输⼊⼤于 0 的整数
        System.out.print("请输⼊ ID，ID 必须是⼤于 0 的整数：");

        // 验证⽤户输⼊的 ID 是否为整数
        if (!MainView.input.hasNextInt()) {
            // 清除⽆效输⼊
            MainView.input.nextLine();
            printError("ID 必须为整数，请输⼊整数值");
            return null;
        }

        // 获取⽤户输⼊的 ID
        int id = MainView.input.nextInt();
        // 清除输⼊缓存中的换⾏符
        MainView.input.nextLine();

        // 验证 ID 是否⼤于 0
        if (id < 1) {
            printError("ID 必须⼤于 0，请重新输⼊");
            return null;
        }

        if (cache == null) {
            // 调⽤服务层获取⽤户列表
            Result result = UserService.list();
            // 将查询到的⽤户数据缓存
            cache = (UserVo[]) result.data;
        }

        //  在缓存中查找指定 ID 的⽤户
        UserVo user = null;
        for (UserVo item : cache) {
            if (item.id == id) {
                // 找到对应 ID 的⽤户，输出⽤户信息
                System.out.println("该 ID 对应的数据是：");
                System.out.printf("id:%d，⽤户名：%s，姓名：%s，⼿机号：%s，邮箱： %s，部⻔名称：%s，⻆⾊名称：%s，状态 \n",
                item.id, item.username, item.name, item.mobile,
                        item.email, item.deptName, item.roleName,
                        item.enabled ? "启⽤" : "禁⽤");
                user = item;
                break;
            }
        }

        // 如果未找到⽤户，则提示⽤户
        if (user == null) {
            printError("当前没有该 ID 对应的数据");
            return null;
        }

        // 返回找到的⽤户信息
        return user;
    }

    /**
     * 更新⽤户信息。
     * <p>
     * 此⽅法允许⽤户根据 ID 更新已存在的⽤户数据。它⾸先通过调⽤ {@link
    #getCacheById()} ⽅法获取需要更新的⽤户信息，
     * 然后提示⽤户输⼊新的数据。⽤户可以选择不修改某些字段，直接按回⻋保持原值。如果输⼊
     ⽆效，⽅法会提示重新输⼊。
     * 最后，⽅法将更新的⽤户信息提交给服务层进⾏更新，并根据结果输出相应的信息。
     * </p>
     *
     * @see #getCacheById() ⽤于获取指定 ID 的⽤户信息
     */
    public static void update() {
        // 获取⽤户信息，如果返回为 null，则退出更新操作
        UserVo user = getCacheById();
        if (user == null) {
            return;
        }

        // 提示⽤户输⼊新的⽤户名，如果⽤户没有输⼊则保持原值
        System.out.print("请输⼊⽤户名，直接按回⻋表示不修改：");
        String username = MainView.input.nextLine();
        username = "".equals(username) ? user.username : username;// 如果为空则使⽤原值

        // 提示⽤户输⼊新的姓名，如果⽤户没有输⼊则保持原值
        System.out.print("请输⼊姓名，直接按回⻋表示不修改：");
        String name = MainView.input.nextLine();
        name = "".equals(name) ? user.name : name; // 如果为空则使⽤原值

        // 提示⽤户输⼊新的⼿机号，如果⽤户没有输⼊则保持原值
        System.out.print("请输⼊⼿机号，直接按回⻋表示不修改：");
        String mobile = MainView.input.nextLine();
        mobile = "".equals(mobile) ? user.mobile : mobile; // 如果为空则使⽤原值

        // 提示⽤户输⼊新的邮箱地址，如果⽤户没有输⼊则保持原值
        System.out.print("请输⼊邮箱，直接按回⻋表示不修改：");
        String email = MainView.input.nextLine();
        email = "".equals(email) ? user.email : email; // 如果为空则使⽤原值

        // 提示⽤户选择部⻔，直到选择有效的部⻔
        int deptId = 0;
        do {
            DeptView.list(); // 列出所有部⻔

            DeptVo dept = DeptView.getCacheById(); // 获取部⻔ ID
            if (dept != null) {
                deptId = dept.id;
            }
        } while (deptId == 0); // 如果选择⽆效则重新选择

        // 提示⽤户选择⻆⾊，直到选择有效的⻆⾊
        int roleId = 0;
        do {
            RoleView.list(); // 列出所有⻆⾊
            RoleVo role = RoleView.getCacheById(); // 获取⻆⾊ ID
            if (role != null) {
                roleId = role.id;
            }
        } while (roleId == 0); // 如果选择⽆效则重新选择

        // 创建新的 UserDto 对象，包含⽤户输⼊的更新数据
        UserDto dto = new UserDto(username, name, mobile, email, deptId, roleId);

        // 调⽤服务层更新⽤户数据
        Result result = UserService.update(dto, user.id);

        // 如果更新失败，输出失败信息并返回
        if (!result.success) {
            printError(result.message);
            return;
        }

        // 如果更新成功，输出成功信息并列出更新后的⽤户信息
        System.out.println(result.message);
        list(); // 列出所有⽤户
    }

    /**
     * 切换⽤户的启⽤/禁⽤状态。
     *
     * <p>该⽅法⽤于根据⽤户输⼊确认是否切换指定⽤户的状态：
     * - 先通过 `getCacheById()` 获取⽤户对象，若⽤户不存在则直接返回。
     * - 若⽤户已启⽤，则提示⽤户输⼊ 'Y' 确认禁⽤，否则提示输⼊ 'Y' 确认启⽤。
     * - 若⽤户未输⼊ 'Y'（忽略⼤⼩写），则取消操作。
     * - 调⽤ `UserService.toggle(user.id)` 切换⽤户状态，并显示操作结果。</p>
     */
    public static void toggle() {
        // 通过⽤户输⼊的 ID 获取缓存中的⽤户对象
        UserVo user = getCacheById();
        if (user == null) {
            return; // 若⽤户不存在，则直接返回
        }

        // 根据当前状态提示⽤户进⾏确认
        if (user.enabled) {
            System.out.print("输⼊'Y'确认禁⽤，输⼊其它取消禁⽤：");}
        else {
            System.out.print("输⼊'Y'确认启⽤，输⼊其它取消启⽤：");
        }

        // 获取⽤户的确认输⼊
        String confirm = MainView.input.nextLine();

        // 若⽤户未输⼊ 'Y'，则取消操作
        if (!"Y".equalsIgnoreCase(confirm)) {
            System.out.println("您已取消修改状态操作");
            return;
        }

        // 调⽤ UserService 切换⽤户状态
        Result result = UserService.toggle(user.id);

        // 若切换失败，则显示错误信息
        if (!result.success) {
            printError(result.message);
            return;
        }

        // 显示操作成功信息
        System.out.println(result.message);

        // 重新加载并显示⽤户列表
        list();
    }
}
